An Environment Supporting Software Process Standardization and Innovation

A critical issue of the design of process-based software development tools and methodologies is the need to balance the desire for innovation with knowledge of past experiences and best practices. This tension between past knowledge and creating new knowledge is particularly acute in the software industry, which involves the development of a highly variable product that dictates the need for continuous process adjustments. The response to this dilemma thus far has been to create software development process frameworks at a generic and very high level of abstraction that avoids the variance found in more detailed levels. While providing a desired measure of standardization, these approaches miss important opportunities to capture and reuse software development knowledge in a manner that can provide valuable resources for software managers, designers, and developers. The approach described in this paper applies rule-based technology to describe software process activities in combination with a case-based organizational learning process that can both disseminate best practices while supporting process innovation. A rule-based software process environment is used to tailor the software process to meet the characteristics of individual projects and provide relevant development knowledge throughout the development lifecycle. This technique also allows the capture of more detailed process descriptions that capture project experiences and emerging requirements as they are encountered in an organization. Capturing process innovation is accomplished through a review process that allows projects to assess the process choices made and provide necessary deviations to meet project needs. These deviations can then be escalated to the repository, allowing the continuous refinement and revision of the process as it is used. 1 Supporting Process Diversity and Knowledge Delivery Software development is a complex, knowledge intensive activity involving the integration of diverse knowledge sources that undergo constant change. The vision of the software engineer carefully crafting language statements into a working program is obsolete, giving way to the employment of an abundance of tools and techniques designed to support creating systems that match the conceptual complexity that modern software users demand. In addition to the hundreds of CASE tools currently available, developers must understand the various process models, development methodologies, usability guidelines, industry standards, and other resources that are required by the tools or otherwise complement them. There are also various technologies, such as interface design, databases, artificial intelligence techniques, Web technology, component technologies, object technologies, and many, many others. Whether or not the proliferation of available resources has led to industry improvements remains unclear, but it is clear is that the “tool mastery burden” [Brooks 1987] for software developers has increased in recent years. Although process-based software engineering is not normally associated with the knowledge burden facing software developers, in many ways process standards embody knowledge of industry best practices. Industry standards, such as ISO 9000 [Kehoe, Jarvis 1996] , Bootstrap [Kuvaja, Bicego 1994], SPICE [Emam et al. 1998; Konrad, Paulk 1995], and the Capability Maturity Model [Paulk et al. 1993] and its growing variants provide information about standard processes that can be measured and evaluated. In addition, process modeling and engineering [Ambriola et al. 1997; Curtis et al. 1992], sometimes referred to as process programming [Osterweil 1987], and associated Process Centered Environments (PCEs) have been researching formal tools for defining, automating and enacting software processes. But the potential of process-based software engineering to provide key knowledge resources to the software developer and manager has yet to be fully explored. The universal scope of process standards naturally migrate toward general and highly abstract procedures and techniques, often reaching a level of “vacuous generality”. Specifying, for example, that configuration management practices must be used covers a very wide range of techniques, and does little to help people understand how configuration management should be practiced in specific development contexts, such as enterprise systems or geographically distributed development teams. PCEs have largely focused on routine activities that can easily be automated, such as configuration management activities. While some environments support process guidance [Fernström 1993; Peuschel et al. 1992], few have explicitly addressed the problem of delivering resources to help software developers perform process activities. Turning current process-based software engineering approaches into repositories of proven practices that can be brought to bear on software development efforts faces a number of interesting challenges. First and foremost is that the knowledge contained in most process models and standards is often idealized and abstracted away from the realities of everyday work practices. The standards restrict themselves to defining the kinds of activities that should be practiced, leaving the actual definition of the activities to the organization. This allows local knowledge and practices to have influence over the standards activities. But diversity within organizations [Johnson, Brodman 2000; Schultz et al. 2000] soon becomes complex, causing the procedures to be defined at an abstract level that once again impedes the ability to specify actual practices. Development efforts are left to “tailor” the process to project needs, usually with little or no guidelines on the parameters for acceptable variations or how the tailoring should be accomplished.